The point of this function is to determine which estimator to use to predict.

• if fallback_method ="raise", we have to have the model for the group we are predicting
• if fallback_method ="next", we check for recursively for the first available parent
• if fallback_method ="global", we summon the global model.

The point of returning a return_level is a trick to know how far back we went, and used to slice an array afterwards (more comments where this happens)

Open question

If y has classes in random order we fall short, should we enforce that?

__target_value__ (and __global_model__ just right after) could be "safe enough" column names, but we can even prefix with __grouped_predictor or __sklego_grouped_predictor to be extra safe that someone is not using those as column names 😂

The fit routine does the following:

• Creates a dataframe with X and y with index being range(0, len(x)
  • If X was already a dataframe it maintains the columns and we just overwrite the index
  • If X was an array, the column names will coincide with the column indexes
• Do some checking on the X,y values
• Add a dummy global model column if required (with a fixed value of 1)
• Based on the arguments (use_global_model, shrinkage and fallback_method) we determine which levels/models need to be fitted by creating a list of lists, where the inner lists are the columns to groupby on
• We train a model for each one of this level/group and their values
  • End up with a dict of key=group_value, value=fitted_estimator
• Define the shrinkage function and factors.
  • If shrinkage is None, instead of doing nothing, I add a factor which is zero everywhere expect for the model trained to be 1.

Send help here 😁

Example here could be:

groups = ["a", "b"]
fitted_levels_ = [["__global_model__"], ["__global_model__", "a"], ["__global_model__", "a", "b"]]

hence grp_names goes from outer to inner and grp_values are the unique values identifying the group

This is a bit of a headache but allows for a unified approach:

• preds is a 3d array of (n_samples, n_levels, n_classes) where for regression or od n_classes can be considered to be 1. This will be populated with a prediction for each level
• shrinkage is a 2d array (n_samples, n_levels) as shrinkage factor is already one per level. This will get the shrinkage to use for each sample. Since we are doing predictions from outer to inner most level, we are overwriting when needed.
• The _get_estimator returning the level allows to select which model shrinkage to use for that particular prediction.
• Finally we multiply preds and shrinkage and sum over all levels.
  • If shrinkage is none, the array will be only zeros and ones, therefore it is equivalent of selecting the model to use
  • If shrinkage is not none, then it is equivalent over averaging with shrinkage factors.

Remark: last_dim_ix is used for the case in #579, using the estimator classes let us index the columns/classes to which assign the results

Decision Function

Decision function breaks for the following reasons:

1. For binary classification, it returns a 1D array
2. For multiclass it returns a 2D array

Therefore for the mix case of group A [0,1,2] and group B [0, 3] it has two different output shapes and most importantly different meaning.

However:

• For the "normal" multiclass cases this implementation works fine, since we are filling the whole preds
• For binary classification it breaks due to the fact that the initialization of preds is which n_classes (=2), yet it is enough to treat this as the regression case.
• The mixed case is just painful - and actually wrong in the current api as well

I guess we should set group_sizes to also be a non-list type in the function definition? Bit of a nit this one.

Also: maybe groups_list instead of lgroups.

Nit: technically the else isn't needed anymore because the function would've returned otherwise. Might be nicer to confirm at the start of the function that a correct fallback method is chosen.

Just noticed we check this elsewhere, so it's probably fine to not check here.